//package com.cy.hui_jie_dan.service.impl;
//
//import com.cy.hui_jie_dan.mapper.FriendMapper;
//import com.cy.hui_jie_dan.mapper.FriendRequestMapper;
//import com.cy.hui_jie_dan.mapper.UserMapper;
//import com.cy.hui_jie_dan.popj.entity.Friend;
//import com.cy.hui_jie_dan.popj.entity.FriendRequest;
//import com.cy.hui_jie_dan.popj.entity.User;
//import com.cy.hui_jie_dan.service.FriendService;
//import com.cy.hui_jie_dan.websocket.WebSocketHandler;
//import org.slf4j.Logger;
//import org.slf4j.LoggerFactory;
//import org.springframework.beans.factory.annotation.Autowired;
//import org.springframework.stereotype.Service;
//import org.springframework.transaction.annotation.Transactional;
//import org.springframework.util.CollectionUtils;
//
//import java.time.LocalDateTime;
//import java.util.ArrayList;
//import java.util.HashMap;
//import java.util.List;
//import java.util.Map;
//import java.util.stream.Collectors;
//
///**
//* @author mjk
//* @description 针对表【friend(好友关系表)】的数据库操作Service实现
//* @createDate 2025-05-13 15:18:19
//*/
//@Service
//public class FriendServiceImpl implements FriendService {
//
//    private static final Logger logger = LoggerFactory.getLogger(FriendServiceImpl.class);
//
//    @Autowired
//    private FriendMapper friendMapper;
//
//    @Autowired
//    private UserMapper userMapper;
//
//    @Autowired
//    private FriendRequestMapper friendRequestMapper;
//
//    @Override
//    public Friend getById(Long id) {
//        return friendMapper.selectById(id);
//    }
//
//    @Override
//    public boolean save(Friend friend) {
//        return friendMapper.insert(friend) > 0;
//    }
//
//    @Override
//    public boolean updateById(Friend friend) {
//        return friendMapper.updateById(friend) > 0;
//    }
//
//    @Override
//    public boolean removeById(Long id) {
//        return friendMapper.deleteById(id) > 0;
//    }
//
//    @Override
//    public List<Map<String, Object>> searchUsers(String keyword, Integer currentUserId) {
//        List<User> users = userMapper.searchUsersByKeyword(keyword);
//        if (CollectionUtils.isEmpty(users)) {
//            return new ArrayList<>();
//        }
//
//        // 获取当前用户的好友列表
//        List<Friend> friendList = friendMapper.selectByUserId(currentUserId);
//        List<Integer> friendIds = friendList.stream()
//                .map(Friend::getFriendId)
//                .collect(Collectors.toList());
//
//        // 获取待处理的好友请求
//        List<FriendRequest> pendingRequests = friendRequestMapper.selectPendingRequestsByFromUserId(currentUserId);
//        List<Integer> pendingRequestIds = pendingRequests.stream()
//                .map(FriendRequest::getToUserId)
//                .collect(Collectors.toList());
//
//        return users.stream()
//                .map(user -> {
//                    Map<String, Object> userMap = new HashMap<>();
//                    userMap.put("userId", user.getUserId());
//                    userMap.put("nickname", user.getNickname());
//                    userMap.put("avatar", user.getAvatar());
//                    userMap.put("phoneNumber", user.getPhoneNumber());
//                    userMap.put("personalExperience", user.getPersonalExperience());
//                    userMap.put("isLoggedOut", user.getIsLoggedOut());
//                    userMap.put("editTime", user.getEditTime());
//                    userMap.put("isFriend", friendIds.contains(user.getUserId()));
//                    userMap.put("hasPendingRequest", pendingRequestIds.contains(user.getUserId()));
//                    return userMap;
//                })
//                .collect(Collectors.toList());
//    }
//
//    @Override
//    @Transactional
//    public void sendFriendRequest(Integer fromUserId, Integer toUserId, String message) {
//        try {
//            // 检查是否已经存在好友请求
//            FriendRequest existingRequest = friendRequestMapper.selectPendingRequestByUserIds(fromUserId, toUserId);
//
//            if (existingRequest != null) {
//                logger.warn("Friend request already exists from user {} to user {}", fromUserId, toUserId);
//                return;
//            }
//
//            // 创建新的好友请求
//            FriendRequest request = new FriendRequest();
//            request.setFromUserId(fromUserId);
//            request.setToUserId(toUserId);
//            request.setMessage(message);
//            request.setStatus(0);
//            request.setCreateTime(LocalDateTime.now());
//            request.setUpdateTime(LocalDateTime.now());
//
//            // 保存好友请求
//            friendRequestMapper.insert(request);
//
//            // 发送WebSocket通知
//            sendFriendRequestNotification(request);
//        } catch (Exception e) {
//            logger.error("Error sending friend request: {}", e.getMessage());
//            throw e;
//        }
//    }
//
//    private void sendFriendRequestNotification(FriendRequest request) {
//        try {
//            // 获取发送者信息
//            User fromUser = userMapper.selectByPrimaryKey(request.getFromUserId());
//            if (fromUser == null) {
//                logger.error("Failed to find user with ID: {}", request.getFromUserId());
//                return;
//            }
//
//            // 构建通知数据
//            Map<String, Object> notificationData = new HashMap<>();
//            notificationData.put("type", "FRIEND_REQUEST");
//            notificationData.put("requestId", request.getId());
//            notificationData.put("fromUserId", request.getFromUserId());
//            notificationData.put("fromUserNickname", fromUser.getNickname());
//            notificationData.put("fromUserAvatar", fromUser.getAvatar());
//            notificationData.put("fromUserPhoneNumber", fromUser.getPhoneNumber());
//            notificationData.put("fromUserPersonalExperience", fromUser.getPersonalExperience());
//            notificationData.put("message", request.getMessage());
//            notificationData.put("timestamp", request.getCreateTime());
//
//            logger.info("Sending friend request notification to user {} from user {}",
//                    request.getToUserId(), request.getFromUserId());
//
//            // 发送WebSocket通知
//            WebSocketHandler.sendFriendRequestNotification(request.getToUserId().longValue(), notificationData);
//        } catch (Exception e) {
//            logger.error("Error sending friend request notification: {}", e.getMessage());
//        }
//    }
//
//    @Override
//    @Transactional
//    public void handleFriendRequest(Long requestId, Integer userId, Integer status) {
//        logger.info("Handling friend request: requestId={}, userId={}, status={}", requestId, userId, status);
//
//        FriendRequest request = friendRequestMapper.selectById(requestId);
//        if (request == null) {
//            logger.error("Friend request not found: requestId={}", requestId);
//            throw new RuntimeException("好友申请不存在");
//        }
//
//        if (!request.getToUserId().equals(userId)) {
//            logger.error("User not authorized to handle this request: userId={}, requestToUserId={}", userId, request.getToUserId());
//            throw new RuntimeException("您无权处理此好友申请");
//        }
//
//        if (request.getStatus() != 0) {
//            logger.error("Friend request already handled: requestId={}, status={}", requestId, request.getStatus());
//            throw new RuntimeException("该申请已处理");
//        }
//
//        // 更新申请状态
//        request.setStatus(status);
//        request.setUpdateTime(LocalDateTime.now());
//        friendRequestMapper.updateById(request);
//
//        if (status == 1) { // 接受申请
//            // 检查是否已经是好友
//            if (isFriend(request.getFromUserId(), request.getToUserId())) {
//                logger.warn("Users are already friends: userId1={}, userId2={}", request.getFromUserId(), request.getToUserId());
//                return;
//            }
//
//            // 创建双向好友关系
//            List<Friend> friends = new ArrayList<>();
//            LocalDateTime now = LocalDateTime.now();
//
//            Friend friend1 = new Friend();
//            friend1.setUserId(request.getFromUserId());
//            friend1.setFriendId(request.getToUserId());
//            friend1.setStatus(0); // 默认状态为0，表示正常好友关系
//            friend1.setCreateTime(now);
//            friend1.setUpdateTime(now);
//            friends.add(friend1);
//
//            Friend friend2 = new Friend();
//            friend2.setUserId(request.getToUserId());
//            friend2.setFriendId(request.getFromUserId());
//            friend2.setStatus(0); // 默认状态为0，表示正常好友关系
//            friend2.setCreateTime(now);
//            friend2.setUpdateTime(now);
//            friends.add(friend2);
//
//            // 批量插入好友关系
//            friendMapper.batchInsertFriends(friends);
//
//            logger.info("Friend request accepted: requestId={}, fromUserId={}, toUserId={}", requestId, request.getFromUserId(), request.getToUserId());
//        } else {
//            logger.info("Friend request rejected: requestId={}, fromUserId={}, toUserId={}", requestId, request.getFromUserId(), request.getToUserId());
//        }
//    }
//
//    @Override
//    public List<Friend> getFriendList(Integer userId) {
//        return friendMapper.selectByUserId(userId);
//    }
//
//    @Override
//    public List<Map<String, Object>> getFriendListWithUserInfo(Integer userId) {
//        return friendMapper.selectFriendListWithUserInfo(userId);
//    }
//
//    @Override
//    public Map<String, Object> getFriendListWithUserInfoPaged(
//            Integer userId,
//            Integer status,
//            String keyword,
//            String orderBy,
//            String orderDirection,
//            Integer pageNum,
//            Integer pageSize) {
//
//        // 计算偏移量
//        Integer offset = (pageNum - 1) * pageSize;
//
//        // 查询好友列表
//        List<Map<String, Object>> friends = friendMapper.selectFriendListWithUserInfoPaged(
//                userId, status, keyword, orderBy, orderDirection, pageSize, offset);
//
//        // 查询总数
//        Integer total = friendMapper.countFriendsByUserId(userId, status, keyword);
//
//        // 构建返回结果
//        Map<String, Object> result = new HashMap<>();
//        result.put("list", friends);
//        result.put("total", total);
//        result.put("pageNum", pageNum);
//        result.put("pageSize", pageSize);
//        result.put("pages", (total + pageSize - 1) / pageSize);
//
//        return result;
//    }
//
//    @Override
//    public List<FriendRequest> getPendingFriendRequests(Integer userId) {
//        return friendRequestMapper.selectPendingRequestsByToUserId(userId);
//    }
//
//    @Override
//    public List<Map<String, Object>> getPendingFriendRequestsWithUserInfo(Integer userId) {
//        List<FriendRequest> requests = getPendingFriendRequests(userId);
//        if (CollectionUtils.isEmpty(requests)) {
//            return new ArrayList<>();
//        }
//
//        // 获取所有发送请求的用户ID
//        List<Integer> fromUserIds = requests.stream()
//                .map(FriendRequest::getFromUserId)
//                .collect(Collectors.toList());
//
//        List<User> users = userMapper.selectByUserIds(fromUserIds);
//        Map<Integer, User> userMap = users.stream()
//                .collect(Collectors.toMap(User::getUserId, user -> user));
//
//        return requests.stream()
//                .map(request -> {
//                    Map<String, Object> requestMap = new HashMap<>();
//                    requestMap.put("requestId", request.getId());
//                    requestMap.put("fromUserId", request.getFromUserId());
//                    requestMap.put("message", request.getMessage());
//                    requestMap.put("status", request.getStatus());
//                    requestMap.put("createTime", request.getCreateTime());
//
//                    User fromUser = userMap.get(request.getFromUserId());
//                    if (fromUser != null) {
//                        requestMap.put("nickname", fromUser.getNickname());
//                        requestMap.put("avatar", fromUser.getAvatar());
//                        requestMap.put("phoneNumber", fromUser.getPhoneNumber());
//                        requestMap.put("personalExperience", fromUser.getPersonalExperience());
//                    }
//
//                    return requestMap;
//                })
//                .collect(Collectors.toList());
//    }
//
//    @Override
//    public List<Map<String, Object>> getFriendRequestHistory(Integer userId) {
//        // 查询发送和接收的好友请求
//        List<FriendRequest> requests = friendRequestMapper.selectRequestHistoryByUserId(userId);
//
//        if (CollectionUtils.isEmpty(requests)) {
//            return new ArrayList<>();
//        }
//
//        // 收集所有涉及的用户ID
//        List<Integer> userIds = new ArrayList<>();
//        for (FriendRequest request : requests) {
//            userIds.add(request.getFromUserId());
//            userIds.add(request.getToUserId());
//        }
//
//        // 查询用户信息
//        List<User> users = userMapper.selectByUserIds(userIds.stream().distinct().collect(Collectors.toList()));
//        Map<Integer, User> userMap = users.stream()
//                .collect(Collectors.toMap(User::getUserId, user -> user));
//
//        return requests.stream()
//                .map(request -> {
//                    Map<String, Object> requestMap = new HashMap<>();
//                    requestMap.put("requestId", request.getId());
//                    requestMap.put("fromUserId", request.getFromUserId());
//                    requestMap.put("toUserId", request.getToUserId());
//                    requestMap.put("message", request.getMessage());
//                    requestMap.put("status", request.getStatus());
//                    requestMap.put("createTime", request.getCreateTime());
//                    requestMap.put("updateTime", request.getUpdateTime());
//
//                    // 判断当前用户是发送者还是接收者
//                    boolean isSender = request.getFromUserId().equals(userId);
//                    requestMap.put("isSender", isSender);
//
//                    // 添加对方的用户信息
//                    Integer otherUserId = isSender ? request.getToUserId() : request.getFromUserId();
//                    User otherUser = userMap.get(otherUserId);
//                    if (otherUser != null) {
//                        requestMap.put("otherUserId", otherUserId);
//                        requestMap.put("otherUserNickname", otherUser.getNickname());
//                        requestMap.put("otherUserAvatar", otherUser.getAvatar());
//                        requestMap.put("otherUserPhoneNumber", otherUser.getPhoneNumber());
//                    }
//
//                    return requestMap;
//                })
//                .collect(Collectors.toList());
//    }
//
//    @Override
//    public boolean isFriend(Integer userId1, Integer userId2) {
//        Integer count = friendMapper.checkFriendship(userId1, userId2);
//        return count != null && count > 0;
//    }
//
//    @Override
//    @Transactional
//    public void deleteFriend(Integer userId1, Integer userId2) {
//        int rows = friendMapper.deleteFriendship(userId1, userId2);
//        logger.info("Deleted {} friend relationships between userId1={} and userId2={}", rows, userId1, userId2);
//    }
//
//    @Override
//    public void updateFriendRemark(Integer userId, Integer friendId, String remark) {
//        int rows = friendMapper.updateFriendRemark(userId, friendId, remark);
//        if (rows > 0) {
//            logger.info("Updated friend remark: userId={}, friendId={}, remark={}", userId, friendId, remark);
//        } else {
//            logger.warn("Failed to update friend remark: userId={}, friendId={}, remark={}", userId, friendId, remark);
//        }
//    }
//
//    @Override
//    public void updateFriendStatus(Integer userId, Integer friendId, Integer status) {
//        int rows = friendMapper.updateFriendStatus(userId, friendId, status);
//        if (rows > 0) {
//            logger.info("Updated friend status: userId={}, friendId={}, status={}", userId, friendId, status);
//        } else {
//            logger.warn("Failed to update friend status: userId={}, friendId={}, status={}", userId, friendId, status);
//        }
//    }
//
//    @Override
//    public Map<Integer, Boolean> batchCheckFriendship(Integer userId, List<Integer> friendIds) {
//        if (CollectionUtils.isEmpty(friendIds)) {
//            return new HashMap<>();
//        }
//
//        List<Map<String, Object>> results = friendMapper.batchCheckFriendship(userId, friendIds);
//        Map<Integer, Boolean> friendshipMap = new HashMap<>();
//
//        // 初始化结果，默认为非好友
//        for (Integer friendId : friendIds) {
//            friendshipMap.put(friendId, false);
//        }
//
//        // 更新好友关系
//        for (Map<String, Object> result : results) {
//            Integer friendId = (Integer) result.get("friend_id");
//            friendshipMap.put(friendId, true);
//        }
//
//        return friendshipMap;
//    }
//
//    @Override
//    @Transactional
//    public void batchAddFriends(Integer userId, List<Integer> friendIds, String remark, Integer status) {
//        if (CollectionUtils.isEmpty(friendIds)) {
//            return;
//        }
//
//        List<Friend> friends = new ArrayList<>();
//        LocalDateTime now = LocalDateTime.now();
//
//        for (Integer friendId : friendIds) {
//            // 检查是否已经是好友
//            if (isFriend(userId, friendId)) {
//                logger.warn("Users are already friends: userId={}, friendId={}", userId, friendId);
//                continue;
//            }
//
//            // 创建双向好友关系
//            Friend friend1 = new Friend();
//            friend1.setUserId(userId);
//            friend1.setFriendId(friendId);
//            friend1.setRemark(remark);
//            friend1.setStatus(status != null ? status : 0);
//            friend1.setCreateTime(now);
//            friend1.setUpdateTime(now);
//            friends.add(friend1);
//
//            Friend friend2 = new Friend();
//            friend2.setUserId(friendId);
//            friend2.setFriendId(userId);
//            friend2.setStatus(0); // 对方默认状态为0
//            friend2.setCreateTime(now);
//            friend2.setUpdateTime(now);
//            friends.add(friend2);
//        }
//
//        if (!CollectionUtils.isEmpty(friends)) {
//            friendMapper.batchInsertFriends(friends);
//            logger.info("Batch added {} friend relationships for userId={}", friends.size() / 2, userId);
//        }
//    }
//}
//
//
//
//
